import axios from 'axios'
import { ElLoading, ElMessage, ElMessageBox } from 'element-plus'
import { getToken } from '@/utils/auth'
import { useUserStore } from '@/stores/index.js'
import router from '@/router/index.js'

// 重复请求
const pendingMap = new Map()

// 加载
const loadingInstance = {
  target: null,
  count: 0
}

/**
 * 全局axios
 */

/**
 * 生成每个请求唯一的键
 * @param {*} config
 * @returns string
 */
function getPendingKey(config) {
  const { url, method, params } = config
  let { data } = config
  if (typeof data === 'string') data = JSON.parse(data) // response里面返回的config.data是个字符串对象
  return [url, method, JSON.stringify(params), JSON.stringify(data)].join('&')
}

/**
 * 储存每个请求唯一值, 也就是cancel()方法, 用于取消请求
 * @param {*} config
 */
function addPending(config) {
  const pendingKey = getPendingKey(config)
  config.cancelToken =
    config.cancelToken ||
    new axios.CancelToken((cancel) => {
      if (!pendingMap.has(pendingKey)) {
        pendingMap.set(pendingKey, cancel)
      }
    })
}

/**
 * 删除重复的请求
 * @param {*} config
 */
function removePending(config) {
  const pendingKey = getPendingKey(config)
  if (pendingMap.has(pendingKey)) {
    const cancelToken = pendingMap.get(pendingKey)
    cancelToken(pendingKey)
    pendingMap.delete(pendingKey)
  }
}

/**
 * 关闭Loading层实例
 * @param {*} _options
 */
function closeLoading(_options) {
  if (_options.loading && loadingInstance.count > 0) loadingInstance.count--
  if (loadingInstance.count === 0) {
    loadingInstance.target.close()
    loadingInstance.target = null
  }
}

/**
 * 处理异常
 * @param {*} error
 */
function httpErrorStatusHandle(error) {
  // 处理被取消的请求
  if (axios.isCancel(error)) return console.warn('请求的重复请求：' + error.message)
  let message = ''
  if (error && error.response) {
    switch (error.response.status) {
      case 302:
        message = '接口重定向了！'
        break
      case 400:
        message = '参数不正确！'
        break
      case 401:
        message = '您未登录，或者登录已经超时，请先登录！'
        break
      case 403:
        message = '您没有权限操作！'
        break
      case 404:
        message = `请求地址出错: ${error.response.config.url}`
        break // 在正确域名下
      case 408:
        message = '请求超时！'
        break
      case 409:
        message = '系统已存在相同数据！'
        break
      case 500:
        message = error.response.data.msg || '服务器内部错误！'
        break
      case 501:
        message = '服务未实现！'
        break
      case 502:
        message = '网关错误！'
        break
      case 503:
        message = '服务不可用！'
        break
      case 504:
        message = '服务暂时无法访问，请稍后再试！'
        break
      case 505:
        message = 'HTTP版本不受支持！'
        break
      default:
        message = '异常问题，请联系管理员！'
        break
    }
  }
  if (error.message.includes('timeout')) message = '网络请求超时！'
  if (error.message.includes('Network')) message = window.navigator.onLine ? '服务端异常！' : '您断网了！'

  ElMessage({
    type: 'error',
    message
  })
}

/**
 * 请求
 * @param config
 * @param custom
 * @param loading
 */
export const request = (config, custom, loading) => {
  // 创建axios
  const Axios = axios.create({
    ...config,
    baseURL: import.meta.env.VITE_BASE_URL + '/adminapi' // url = base url + request url
  })
  // 自定义配置
  const customOptions = Object.assign(
    {
      repeat_request_cancel: true, // 是否开启取消重复请求, 默认为 true
      loading: false, // 是否开启loading层效果, 默认为false
      reduct_data_format: true, // 是否开启简洁的数据结构响应, 默认为true
      error_message_show: true, // 是否开启接口错误信息展示,默认为true
      code_success_show: false, // 是否开启code为0时的信息提示, 默认为false
      code_error_show: true // 是否开启code不为0时的信息提示, 默认为false
    },
    custom
  )

  /**
   *请求拦截
   */
  Axios.interceptors.request.use(
    (config) => {
      removePending(config)
      customOptions.repeat_request_cancel && addPending(config)
      if (customOptions.loading) {
        loadingInstance.count++
        if (loadingInstance.count === 1) {
          loadingInstance.target = ElLoading.service(loading)
        }
      }
      // 自动携带token
      config.headers['Access-Token'] = getToken()
      config.params = config.params || {}
      config.params._ajax = 1
      return config
    },
    (error) => {
      return Promise.reject(error)
    }
  )

  /**
   * 响应拦截
   */
  Axios.interceptors.response.use(
    (response) => {
      removePending(response.config)
      customOptions.loading && closeLoading(customOptions) // 关闭loading
      const res = response.data
      const code = res.code

      if (code === 0) {
        customOptions.code_success_show && ElMessage.success(res.msg)
        return res
      } else {
        customOptions.code_error_show && ElMessage.error(res.msg)
        switch (code) {
          case -1:
            if (customOptions.code_message_show) {
              ElMessage.error(res.msg)
            }
            return Promise.reject(res)
          case -2:
            return Promise.reject(res)
          case 401:
            // 登录状态
            ElMessageBox.confirm('您已注销，可以取消以停留在此页面，或重新登录', '确认注销', {
              confirmButtonText: '重新登录',
              cancelButtonText: '关闭',
              type: 'warning'
            }).then(() => {
              const userStore = useUserStore()
              userStore.resetToken().then(() => {
                location.reload()
              })
            })
            return Promise.reject(res)
          case 402:
            // 管理员没权限
            if (customOptions.code_message_show) {
              ElMessage.error(res.msg)
            }
            return Promise.reject(res)
          case 403:
            // 普通用户没权限
            if (customOptions.code_message_show) {
              ElMessage.error(res.msg)
            }
            router.push('/')
            return Promise.reject(res)
          default:
            return Promise.reject(response.data || { msg: '未知错误' })
        }
      }
    },
    (error) => {
      console.log('error', error)
      error.config && removePending(error.config)
      customOptions.error_message_show && httpErrorStatusHandle(error) // 处理错误状态码
      customOptions.loading && closeLoading(customOptions) // 关闭loading
      return Promise.reject(error)
    }
  )
  // 发送请求
  return Axios.request(config)
}

export default request
